﻿#include <iostream>

using namespace std;

class A
{
public:
	//构造
	A(int a = 0)
		:_a(a)
	{
		++N;
	}
	//拷贝构造
	A(const A& aa)
		:_a(aa._a)
	{
		N++;
	}

	//没有this指针，只能访问静态成员
	static int GetN()
	{
		return N;
	}
private:
	int _a;

	static int N;//声明
};

//生命周期是全局，但作用域受类域限制
int A::N = 0;//定义初始化

void f1(A aa)
{

}

A f2()
{
	A aa;
	return aa;
}

int main()
{
	A aa1(1);
	A aa2 = 2;
	A aa3 = aa1;

	std::cout << aa1.GetN() << std::endl;

	f1(aa1);
	std::cout << aa1.GetN() << std::endl;
	f2();
	std::cout << aa1.GetN() << std::endl;
	return 0;
}


//要求类对象只能在栈上面
class A
{
public:
	static A GetObj(int a = 0)
	{
		A aa(a);
		return aa;
	}
private:
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};

int main()
{
	A aa = A::GetObj(1);

	int arr[3] = { 1,2,3 };
	for (auto& a : arr)
	{
		a--;
	}

	for (auto)
		return 0;
}


class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B
{
public:
	B(int a, int ref)
		:_aobj(a)	//初始化列表
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj; //没有默认构造函数
	int& _ref; //引用
	const int _n; // const 
};




class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B
{
public:
	// 对象每个成员什么时候定义初始化呢？-- 初始化列表
	// 每个成员都要走初始化列表，就算不显示在初始化列表写，也会走
	// 如果在初始化列表显示写了就用显示写的初始化
	// 如果没有在初始化列表显示初始化
	// 1、内置类型，有缺省值用缺省值，没有就用随机值
	// 2、自定义类型，调用默认它的默认构造函数，如果没有默认构造就报错
	B()
		:_n(10)
		, _m(2)
		, _aa(11)
	{
		// _n = 10;
	}

private:
	// const成员
	const int _n;  // 声明
	int _m = 1;    // 缺省值

	A _aa;
};


class A
{
public:
	A(int a)
		:_a1(a)	//_a1初始化为1
		, _a2(_a1)	//_a2定义在_a1前，所以_a2先初始化，但此时_a1并未初始化为1
					//所以_a1为随机值，_a2也就被初始化为随机值
	{}

	void Print()
	{
		std::cout << _a1 << " " << _a2 << std::endl;//输出‘1 随机值’
	}
private:
	int _a2;	//_a2定义在_a1前
	int _a1;
};
int main()
{
	A aa(1);
	aa.Print();
}


int main()
{
	int num = 1;
	for (int i = 7; i >= 0; i--)
	{
		if (num & (1 << i))
			std::cout << "1";
		else
			std::cout << "0";
	}
	return 0;
}